'''

类的基本练习

'''
from datetime import  datetime
import numpy as np
class Man:
    def __init__(self, name):
        self.name = name
        print("Man类的init方法被调用！！！")

    def say_hello(self):
        print("你好啊"+self.name)

    def say_goodbye(self):
        print("再见"+self.name)

man1 = Man("lzq")
man1.say_hello()
man1.say_goodbye()

print("--------------------------------")
arr11 = np.array([1,2,3,4,5,6,7,8,9])
arr12 = np.array([1,2,3,4,5,6,7,8,9])
#print(arr11)
print(arr11+arr12)  #[ 2  4  6  8 10 12 14 16 18]




'''
在使用 numpy 进行数组输出时，其默认的打印对齐方式是由 numpy 内部的打印设置所决定的，目的是为了更清晰地展示数组元素的结构和数值，尤其是当数组元素存在不同位数、不同类型（比如有整数、浮点数等混合情况）时，这样的对齐方式能让用户更直观地区分各个元素。
如果想要调整输出的对齐方式，可以借助 numpy.set_printoptions 函数来进行设置。
例如，若要设置左对齐，可以结合格式化字符串等方式来实现更自定义的输出格式，不过这需要对 numpy 的打印选项以及 Python 的字符串格式化有一定了解。一般情况下，numpy 默认的对齐展示方式是经过设计、便于数据查看的，若没有特殊的排版需求，使用默认方式即可。
'''

print(arr11/arr12) #[1. 1. 1. 1. 1. 1. 1. 1. 1.]
print(arr11*arr12) #[ 1  4  9 16 25 36 49 64 81]'

print(4/2)

print("--------------------------------")
arr2 = [1,3,5,7,9]
print(arr2)

#print(type(arr1))   #<class 'numpy.ndarray'>
print(type(arr2))  #<class 'list'>


x = 123454321



print("-------------------")
i = 0
while(i<5):
    print("当前",i)
    i+=1
else:   ##python中特殊的语法
    print("程序正常循环结束")


def add(a,b,c):
    return a+b+c

print(add(1,2,3))

print(add('a','b','c'))

print("-------------------")

numbers  = ['a','b','c']  #这是python的列表
print(type(numbers))  #<class 'list'>
numbers.append('d')
print(numbers)  #['a', 'b', 'c', 'd']
numbers.pop(1)
print(numbers)  #['a', 'c', 'd']  把下标为1的元素弹出



map11 = {"id":"1","age":"10"}
print(map11)  #{'id': '1', 'age': '10'}  ##这是python的字典
'''
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If the key is not found, return the default if given; otherwise, raise a KeyError.
'''
print(map11.pop("id"))  #1
#print(map11.pop("id1"))  #报错 弹出一个KeyError错误

print(map11)  #{'age': '10'}  把键位id的键值对弹出后 就只剩age了

try:
    result = 1/1
    t1 = int(9.9)
    print(t1)
except ZeroDivisionError:
    print("哦 除以0异常")
except TypeError:
    print("未知异常")
else:
    print("没问题,结果是:",result)
finally:
    print("无论是否有异常，这里都执行")

dateTime = datetime.now()
print(dateTime) #2025-09-21 21:52:25.563991


import  math
print(math.sqrt(10000)) ##100.0

str1 = """床前明月光,
疑是地上霜。
"""
print(str1)  ##在 Python 中，使用三引号（""" 或 '''）创建的字符串是多行字符串。当你像这样编写：
# 三引号会将引号内的所有内容（包括换行和其中的文字）都作为字符串的一部分。所以 str1 不是空字符串，而是包含了两行文字："床前明月光，\n疑是地上霜。\n"（\n 表示换行符）。


##range(10) 生成 0 到 9 的整数序列（不包含 10）
## x **2 计算每个整数 x 的平方

squ = [x ** 2 for x in range (10)]  ##[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]   python的列表推导式
print(squ)


squ = [x * 2 for x in range (10)]  ##[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
print(squ)



squ = []
for x in range(10):
    squ.append(x** 2)
print(squ)   ##[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

age = 100
print("成年了！"if age>=18 else "未成年！")

print("成年了! " if age>=18 else "未成年！")


a = 1
b = 2
a,b  = b,a  ##python直接交换变量 无需java那种需要依赖一个中间变量
print("a=",a,"b=",b)

#python 一个函数可以返回多个值
def m1():
    return "张三",28,'男','北京市'

name1,age1,gender1,address1 = m1()  #python 一个函数可以返回多个值  直接接收就行
print(name1,age1,gender1,address1)  #张三 28 男 北京市

print(type(m1()),m1())  # <class 'tuple'> ('张三', 28, '男', '北京市')

#python函数可以设置默认值 java得需要重载函数的支持
def greet(name,content = "您好"):
    print(name+","+content)

greet("张三") #张三,您好
greet("李四","好骚啊")  #李四,好骚啊

#python调用函数时，可以指定参数名 不用按顺序传参 java则不行
def add1(a,b,c):
    return a+b*c


print(add1(b=3,a=4,c=100))  ##304



#python用*args(可以换成其他变量名 但是*不能替换)可以接收数量不定的参数  java用...
def sum_all(*args):
    result = 0;
    for i in args:
        result+=i
    return result

print(sum_all(1,2,3,4,5))
print(sum_all(1,2,3))

#python的匿名函数 加法匿名函数  关键字 lambda
add  = lambda a,b,c : a+b*c
print(add(1,20,3))  #61

#对学生排序 进一步使用lambda
stus = [("张三",18),("李四",16),("王五",20)]
stus_sorted = sorted(stus,key=lambda x:x[1])
stus_sorted_re = sorted(stus,key=lambda x:x[1],reverse=True)  ##reverse表示降序了 对年龄进行降序

print(stus_sorted)
print(stus_sorted_re)  #[('王五', 20), ('李四', 19), ('张三', 18)]



'''
在 Python 中，yield 关键字用于定义生成器函数（generator function），它的作用类似于 return，但会使函数返回一个生成器对象（generator），而不是直接返回值。生成器可以逐步产生值，而不是一次性生成所有结果，这种特性使其在处理大量数据或无限序列时非常高效（节省内存）。
基本用法与原理
当函数中包含 yield 时，它就不再是普通函数，调用时不会立即执行函数体，而是返回一个生成器对象。每次通过 next() 函数或 for 循环迭代生成器时，
函数会执行到 yield 语句处，返回 yield 后面的值，并暂停执行（保留当前的状态，如变量值、执行位置等）。下次迭代时，从暂停的位置继续执行，直到再次遇到 yield 或函数结束。

特点：
惰性计算：生成器不会一次性生成所有结果，而是按需产生，适合处理大数据量（避免占用大量内存）。
状态保留：每次 yield 后，函数的状态（变量、执行位置）会被保存，下次迭代时从暂停处继续，无需重新初始化。

可迭代性：生成器对象是可迭代的（iterable），可以直接用于 for 循环，也可以通过 list() 转换为列表（但会失去内存优势）。



'''
def count_up_to(n):
    i = 0
    while i <= n:
        yield i  # 每次返回i，并暂停
        i += 1


def count_up_to2(n):
    i = 0
    while i <= n:
        yield i**2  # 每次返回i，并暂停   这里可以决定 返回什么值 比如：返回i本身还是平方
        i += 1


print(">>>>>>>>>>>>>>>>>>>>>")
# 调用生成器函数，返回生成器对象
##当函数中(count_up_to)包含 yield 时，它就不再是普通函数，调用时不会立即执行函数体，而是返回一个生成器对象。 所以 generator是生成器对象
generator = count_up_to(3)
print(generator) #<generator object count_up_to at 0x000001797F172680>
print(list(generator)) #[0, 1, 2, 3]  如果这里已经转换为list输出了 后面就不能继续用next取了 已经取光了

# 迭代生成器
print(next(generator))  # 输出：0（第一次执行到yield，返回0，暂停）
print(next(generator))  # 输出：1（从暂停处继续，i变为1，返回后暂停）
print(next(generator))  # 输出：2
print(next(generator))  # 输出：3
#print(next(generator))  # 这一句 会抛出StopIteration异常（函数执行结束）

##也可以用for循环
for num in count_up_to(3):
    print(num)  # 依次输出：0, 1, 2, 3

print("-----------------------")
for num in count_up_to2(10):  ##输出0-10的平方
    print(num)  # 依次输出：0, 1,4,9,16，25.........